/**
* 显示消息提示框
* @param content 提示的标题
*/
export function toast(content) {
  uni.showToast({
    icon: 'none',
    title: content
  })
}

/**
* 显示模态弹窗
* @param content 提示的标题
*/
export function showConfirm(content) {
  return new Promise((resolve, reject) => {
    uni.showModal({
      title: '提示',
      content: content,
      cancelText: '取消',
      confirmText: '确定',
      success: function(res) {
        resolve(res)
      }
    })
  })
}

/**
* 参数处理
* @param params 参数
*/
export function tansParams(params) {
  let result = ''
  for (const propName of Object.keys(params)) {
    const value = params[propName]
    var part = encodeURIComponent(propName) + "="
    if (value !== null && value !== "" && typeof (value) !== "undefined") {
      if (typeof value === 'object') {
        for (const key of Object.keys(value)) {
          if (value[key] !== null && value[key] !== "" && typeof (value[key]) !== 'undefined') {
            let params = propName + '[' + key + ']'
            var subPart = encodeURIComponent(params) + "="
            result += subPart + encodeURIComponent(value[key]) + "&"
          }
        }
      } else {
        result += part + encodeURIComponent(value) + "&"
      }
    }
  }
  return result
}

// 限制输入的小数位数
export function handleBudgetInput(value, decimalPlaces = 2, callback = () => {}) {
  // 1. 清除所有非数字和非小数点的字符（包括字母）
  let filtered = value.replace(/[^\d.]/g, '')

  // 2. 只保留第一个小数点，清除后续所有小数点
  const firstDotIndex = filtered.indexOf('.')
  if (firstDotIndex !== -1) {
    // 保留第一个小数点前的内容 + 第一个小数点 + 后面的数字（去掉后续小数点）
    filtered = filtered.substring(0, firstDotIndex + 1) +
      filtered.substring(firstDotIndex + 1).replace(/\./g, '')
  }

  // 3. 限制小数点后最多2位
  // filtered = filtered.replace(/^(\d+)\.(\d{1,2}).*$/, '$1.$2')
  const regex = new RegExp(`^(\\d+)\\.(\\d{1,${decimalPlaces}}).*$`, '');
  filtered = filtered.replace(regex, '$1.$2')

  // 4. 处理开头为小数点的情况（补0）
  if (filtered.startsWith('.')) {
    filtered = '0' + filtered
  }
  callback(filtered)
}

export function handleIntegerInput(value, callback = () => {}, max=-1) {
  // max为整数
  // 清除所有非数字的字符
  let filtered = value.replace(/[^\d]/g, '')

  // 处理前导零：如果以0开头且长度大于1，移除前导零
  if (filtered.length > 1 && filtered.startsWith('0')) {
    filtered = filtered.replace(/^0+/, '') || '0'
  }
  if (max > 0 && Number(filtered) > max) {
    filtered = max
  }
  callback(filtered)
}

export function formatTime(isoTime) {
  const date = new Date(isoTime); // 解析 ISO 时间格式

  // 获取年、月、日（月份从 0 开始，需 +1）
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0'); // 补零（如 9 → "09"）
  const day = String(date.getDate()).padStart(2, '0');

  // 获取时、分、秒
  const hours = String(date.getHours()).padStart(2, '0');
  const minutes = String(date.getMinutes()).padStart(2, '0');
  const seconds = String(date.getSeconds()).padStart(2, '0');

  // 拼接为 "YYYY-MM-DD HH:MM:SS" 格式
  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
}

/**
 * 计算两个时间的差值，格式化为“XX天XX小时”
 * @param {string} endTime - 结束时间（格式：YYYY-MM-DD HH:mm:ss）
 * @param {string} startTime - 开始时间（格式：YYYY-MM-DD HH:mm:ss）
 * @returns {string} 格式化结果（如：21天0小时）
 */
export function getTimeDiffInDaysHours(endTime, startTime) {
  // 1. 转为时间对象（处理时间字符串）
  const endDate = new Date(endTime);
  const startDate = new Date(startTime);

  // 2. 校验时间格式是否合法
  if (isNaN(endDate.getTime()) || isNaN(startDate.getTime())) {
    return "时间格式错误（需为YYYY-MM-DD HH:mm:ss）";
  }

  // 3. 计算总毫秒差（确保差值为正，避免结束时间早于开始时间）
  const totalMs = Math.abs(endDate.getTime() - startDate.getTime());

  // 4. 拆解为“天”和“小时”
  const oneDayMs = 24 * 60 * 60 * 1000; // 1天的毫秒数：86400000
  const oneHourMs = 60 * 60 * 1000; // 1小时的毫秒数：3600000

  const days = Math.floor(totalMs / oneDayMs); // 整数天
  const remainingMs = totalMs % oneDayMs; // 剩余毫秒数
  const hours = Math.floor(remainingMs / oneHourMs); // 剩余小时数

  // 5. 格式化输出（补0处理，如“1天2小时”“0天3小时”）
  return `${days}天${hours}小时`;
}

/**
 * 判断时间段是否有错误
 * @param {Array} timeRange - 时间段数组，格式 [开始时间, 结束时间]
 * @param {Boolean} allowSameTime - 是否允许开始时间等于结束时间（默认允许）
 * @returns {Object} 结果：{ isError: 布尔值, errorMsg: 错误信息 }
 */
export function checkTimeRangeError(timeRange, allowSameTime = true) {
  // 1. 先校验数组格式（必须是长度为2的数组）
  if (!Array.isArray(timeRange) || timeRange.length !== 2) {
    return {
      isError: true,
      errorMsg: "时间段格式错误：必须传入 [开始时间, 结束时间] 格式的数组"
    };
  }

  const [startTimeStr, endTimeStr] = timeRange;
  // 2. 校验时间字符串是否为空
  if (!startTimeStr || !endTimeStr) {
    return {
      isError: true,
      errorMsg: "时间段错误：开始时间或结束时间不能为空"
    };
  }

  // 3. 校验时间格式（正则匹配 YYYY-MM-DD HH:MM，可根据需求扩展到秒）
  const timeReg = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/;
  if (!timeReg.test(startTimeStr) || !timeReg.test(endTimeStr)) {
    return {
      isError: true,
      errorMsg: "时间段格式错误：需符合 YYYY-MM-DD HH:MM 格式（如 2025-10-13 00:00）"
    };
  }

  // 4. 校验时间是否为真实有效时间（避免 2025-02-30、2025-13-01 等无效日期）
  const startTime = new Date(startTimeStr);
  const endTime = new Date(endTimeStr);
  // 注意：Invalid Date 的 getTime() 会返回 NaN
  if (isNaN(startTime.getTime()) || isNaN(endTime.getTime())) {
    return {
      isError: true,
      errorMsg: "时间段错误：包含无效日期（如 2025-02-30、2025-13-01 等）"
    };
  }

  // 5. 校验时间逻辑（开始时间是否早于/等于结束时间）
  const startTimestamp = startTime.getTime();
  const endTimestamp = endTime.getTime();
  if (allowSameTime) {
    // 允许同一时刻（如 [2025-10-13 00:00, 2025-10-13 00:00] 合法）
    if (startTimestamp > endTimestamp) {
      return {
        isError: true,
        errorMsg: "时间段逻辑错误：开始时间不能晚于结束时间"
      };
    }
  } else {
    // 不允许同一时刻（需开始时间 < 结束时间，保证时间段有长度）
    if (startTimestamp >= endTimestamp) {
      return {
        isError: true,
        errorMsg: "时间段逻辑错误：开始时间必须早于结束时间（不允许同一时刻）"
      };
    }
  }

  // 6. 所有校验通过
  return {
    isError: false,
    errorMsg: "时间段合法"
  };
}